"""
Reinforcement learning maze example.

maze环境是一个4x4的网格迷宫环境,主要包含以下元素：
1. 探索者(红色方块):代表智能体 初始位置在左上角 可以进行上、下、左、右四种动作
2. 陷阱(黑色方块):有两个陷阱位置 掉入陷阱获得-1奖励 游戏结束
3. 目标(黄色圆形):代表终点 到达目标获得+1奖励 游戏结束
4. 普通地面(白色格子):移动到普通地面获得0奖励 游戏继续

环境的主要功能：
reset():重置环境到初始状态
step(action):执行动作并返回下一个状态、奖励和是否结束
render()):渲染当前状态

技术实现：
使用Tkinter构建图形界面
每个格子大小为40像素
总尺寸为160x160像素
使用Canvas绘制各种图形元素

这个环境是为强化学习算法设计的,特别适合用来学习和测试Q-learning等算法.

Red rectangle:          explorer.
Black rectangles:       hells       [reward = -1].
Yellow bin circle:      paradise    [reward = +1].
All other states:       ground      [reward = 0].

This script is the environment part of this example. The RL is in RL_brain.py.

Reference: https://morvanzhou.github.io/tutorials/
"""


import numpy as np
import time #time是用来处理时间的库
import sys #sys是用来处理命令行参数的库
if sys.version_info.major == 2: #判断是否是python2，如果是，导入Tkinter库
    import Tkinter as tk
else:
    import tkinter as tk #tkinter是python的GUI库


UNIT = 40   # pixels 定义迷宫中每个格子的大小为40像素
MAZE_H = 4  # grid height
MAZE_W = 4  # grid width


class Maze(tk.Tk, object): #定义一个名为Maze的类，继承自Tkinter的Tk类和object类
    def __init__(self): #初始化环境
        super(Maze, self).__init__() #调用父类的初始化方法
        self.action_space = ['u', 'd', 'l', 'r'] #定义动作空间
        self.n_actions = len(self.action_space) #定义动作数量
        self.title('maze') #设置窗口标题
        self.geometry('{0}x{1}'.format(MAZE_W * UNIT, MAZE_H * UNIT)) 
        #设置窗口大小,单位为像素,大小为4x4个格子,每个格子40像素,'
        #{0}x{1}'是字符串格式化,'{0}'和'{1}'是占位符,分别代表MAZE_W和MAZE_H
        self._build_maze() #构建迷宫

    def _build_maze(self): #构建迷宫
        self.canvas = tk.Canvas(self, bg='white', #设置画布背景颜色为白色
                           height=MAZE_H * UNIT,
                           width=MAZE_W * UNIT)

        # create grids 
        for c in range(0, MAZE_W * UNIT, UNIT):
            x0, y0, x1, y1 = c, 0, c, MAZE_H * UNIT #定义一个矩形的左上角和右下角坐标
            #x0,y0是左上角坐标,x1,y1是右下角坐标
            self.canvas.create_line(x0, y0, x1, y1) #create_line()是Tkinter的方法,用于在画布上创建直线
        for r in range(0, MAZE_H * UNIT, UNIT): 
            x0, y0, x1, y1 = 0, r, MAZE_W * UNIT, r
            self.canvas.create_line(x0, y0, x1, y1)

        # create origin 创建起点
        origin = np.array([20, 20]) #定义一个点的坐标

        # hell 创建陷阱
        hell1_center = origin + np.array([UNIT * 2, UNIT]) 
        #坐标为起点坐标加上一个向量,向量的长度为UNIT,向量的方向为向右
        #hell1_center是陷阱1的中心坐标
        self.hell1 = self.canvas.create_rectangle( #create_rectangle()是Tkinter的方法,用于在画布上创建矩形
            hell1_center[0] - 15, hell1_center[1] - 15,
            hell1_center[0] + 15, hell1_center[1] + 15,
            fill='black') #fill='black'是设置矩形的填充颜色为黑色
        # hell #陷阱2
        hell2_center = origin + np.array([UNIT, UNIT * 2])
        self.hell2 = self.canvas.create_rectangle(
            hell2_center[0] - 15, hell2_center[1] - 15,
            hell2_center[0] + 15, hell2_center[1] + 15,
            fill='black')

        # create oval 创建目标
        oval_center = origin + UNIT * 2
        self.oval = self.canvas.create_oval( #create_oval()是Tkinter的方法,用于在画布上创建椭圆
            oval_center[0] - 15, oval_center[1] - 15,
            oval_center[0] + 15, oval_center[1] + 15,
            fill='yellow') #fill='yellow'是设置椭圆的填充颜色为黄色

        # create red rect 创建红色矩形
        self.rect = self.canvas.create_rectangle(
            origin[0] - 15, origin[1] - 15,
            origin[0] + 15, origin[1] + 15,
            fill='red')

        # pack all 打包所有元素，并显示窗口
        self.canvas.pack() #pack()是Tkinter的方法,用于将元素打包到窗口中

    def reset(self): #重置环境到初始状态
        self.update()
        time.sleep(0.5) #暂停0.5秒
        self.canvas.delete(self.rect) #删除红色矩形
        origin = np.array([20, 20]) #定义起点坐标
        self.rect = self.canvas.create_rectangle( #创建红色矩形
            origin[0] - 15, origin[1] - 15,
            origin[0] + 15, origin[1] + 15,
            fill='red')
        # return observation 返回红色矩形的坐标
        return self.canvas.coords(self.rect)

    def step(self, action): #执行动作并返回下一个状态、奖励和是否结束
        s = self.canvas.coords(self.rect) #获取红色矩形的坐标，coords()是Tkinter的方法,用于获取元素的坐标
        #s是一个列表,列表的第一个元素是红色矩形的左上角x坐标,第二个元素是左上角y坐标,第三个元素是右下角x坐标,第四个元素是右下角y坐标
        base_action = np.array([0, 0]) 
        if action == 0:   # up
            if s[1] > UNIT:
                base_action[1] -= UNIT
        elif action == 1:   # down
            if s[1] < (MAZE_H - 1) * UNIT:
                base_action[1] += UNIT
        elif action == 2:   # right
            if s[0] < (MAZE_W - 1) * UNIT:
                base_action[0] += UNIT
        elif action == 3:   # left
            if s[0] > UNIT:
                base_action[0] -= UNIT

        self.canvas.move(self.rect, base_action[0], base_action[1])  
        # move agent 动作执行后，更新红色矩形的坐标
        s_ = self.canvas.coords(self.rect)  # next state 获取红色矩形的新坐标


        # reward function 判断是否到达目标或掉入陷阱
        if s_ == self.canvas.coords(self.oval):
            reward = 1
            done = True
            s_ = 'terminal'
        elif s_ in [self.canvas.coords(self.hell1), self.canvas.coords(self.hell2)]: #判断是否掉入陷阱
            reward = -1
            done = True
            s_ = 'terminal'
        else:
            reward = 0
            done = False

        return s_, reward, done

    def render(self): #渲染当前状态
        time.sleep(0.5)
        self.update() #更新窗口


def update():
    for t in range(10):
        s = env.reset()
        while True:
            env.render()
            a = 1
            s, r, done = env.step(a)
            if done:
                break

if __name__ == '__main__':
    env = Maze()
    env.after(150, update) #100毫秒后调用update()函数
    env.mainloop() #mainloop()是Tkinter的方法,用于进入消息循环